package cn.biplam.common.paramters;

import cn.biplam.common.tools.TOOLS;
import cn.biplam.common.wrapper.ErrorMessage;

/**
 * 数据探查属性
 */
public class DbsParam {

	public enum Task_Type{
		/**模型导入任务*/
		Model_Import("1"),
		/**数据探查任务*/
		DbSearch("2");
		private String value;
		private Task_Type(String value){this.value=value;}
		public String toString() {return value;}
	}

	/**
	 * 主键探查附加标志类型
	 */
	public enum Field_Dbs_Pk_Flag {
		/** 0:可以排除 */
		Allow_Exclude("0"),
		/** 1:必须包含 */
		Must_Include("1");
		private String value;
	
		private Field_Dbs_Pk_Flag(String value) {
			this.value = value;
		}
	
		public String toString() {
			return value;
		}
	}

	/**
	 * 探查结果类型
	 */
	public enum Dbs_Reuslt_Type{
		/** 未知*/
		Unknow("0"),
		/** 通过*/
		Passed("1"),
		/** 未通过*/
		Failed("2"),
		/** 规则异常*/
		Error("3");
		private String value;
		private Dbs_Reuslt_Type(String value){this.value=value;}
		public String toString() {return value;}
	}

	/**
	 * 允许类型
	 */
	public enum Allow_Type {
		/** 不允许 */
		UNALLOW("0"),
		/** 允许 */
		ALLOW("1");
		private String value;
	
		private Allow_Type(String value) {
			this.value = value;
		}
	
		public String toString() {
			return value;
		}
	}

	/**
	 * 默认泛查规则
	 */
	public enum Default_Dbs_Rule{
		/** 符号代码泛查 */
		Code("021"),
		/** 空值泛查 */
		Empty("041"),
		/** 数据范围泛查 */
		Data_Range("031");
		private String value;
		private Default_Dbs_Rule(String value) {
			this.value = value;
		}
		public String toString() {
			return value;
		}
	}

	/**
	 * 字段探查规则类型
	 */
	public enum Field_Dbs_Rule_Type {
		/** 1: 标准代码 */
		Stand_Code("1"),
		/** 2: 符号代码 */
		Symbol_Code("2"),
		/** 3: 数据范围 */
		Data_Range("3"),
		/** 4: 空值 */
		Null_Value("4");
		private String value;
	
		private Field_Dbs_Rule_Type(String value) {
			this.value = value;
		}
	
		public String toString() {
			return value;
		}
	}

	/**
	 * 外键探查附加标志
	 */
	public enum Dbs_Fk_Extra_Flag {
		/** 允许空值 */
		Allow_Null("0"),
		/** 1:严格匹配 */
		Strict_Match("1");
		private String value;
		private Dbs_Fk_Extra_Flag(String value) {
			this.value = value;
		}
		public String toString() {
			return value;
		}
	}

	/**
	 * 根据探查结果标示获取探查结果类型
	 * @param result 探查结果标示 
	 * @return 探查结果类型
	 * @throws ErrorMessage
	 */
	public static Dbs_Reuslt_Type getResult(String result) throws ErrorMessage{
		if("0".equals(result)){
			return Dbs_Reuslt_Type.Unknow;
		}else if("1".equals(result)){
			return Dbs_Reuslt_Type.Passed;
		}else if("2".equals(result)){
			return Dbs_Reuslt_Type.Failed;
		}else if("3".equals(result)){
			return Dbs_Reuslt_Type.Error;
		} else{
			throw new ErrorMessage("Result "+result+" is an unknow result!");
		}
	}

	/**
	 * 根据探查结果标示获取探查结果描述
	 * @param result 探查结果标示 
	 * @return 探查结果描述
	 * @throws ErrorMessage
	 */
	public static String getResultDesc(String result) throws ErrorMessage{
		if("0".equals(result)){//"未知"
			return "";
		}else if("1".equals(result)){
			return "通过";
		}else if("2".equals(result)){
			return "未通过";
		}else if("3".equals(result)){
			return "规则异常";
		} else{
			return null;
		}
	}

	/**
	 * 根据主键附加探查结果描述
	 * @param result 探查结果标示 
	 * @return 探查结果描述
	 * @throws ErrorMessage
	 */
	public static String getPkMultiResultDesc(String result) throws ErrorMessage{
		if("0".equals(result)){//"未知"
			return "";
		}else if("1".equals(result)){
			return "该字段必须包含在复合主键字段内,否则主键不唯一";
		}else if("2".equals(result)){
			return "该字段非复合主键必须字段";
		}else if("3".equals(result)){
			return "规则异常";
		} else{
			return null;
		}
	}

	/**
	 * 根据字段的主键附加探查结果
	 * @param result 探查结果标示 
	 * @return 探查结果描述
	 * @throws ErrorMessage
	 */
	public static String getFieldPkMultiResult(String result) throws ErrorMessage{
		if("0".equals(result)){//"未知"
			return "";
		}else if("1".equals(result)){
			return "复合主键必须字段";
		}else if("2".equals(result)){
			return "非复合主键必须字段";
		}else if("3".equals(result)){
			return "";
		} else{
			return null;
		}
	}

	/**
	 * 获取外键关系结果描述
	 * @param fkIntegrity 外键完整性
	 * @param haveNull    是否存在空值
	 * @return
	 */
	public static String getFkResultDesc(String result,String fkIntegrity,String haveNull){
		StringBuilder sp = new StringBuilder();
		if(Dbs_Reuslt_Type.Error.toString().equals(result)){
			sp.append("规则异常");
			return sp.toString();
		}
		if("0".equals(fkIntegrity)){
			sp.append("");
		}else if("1".equals(fkIntegrity)){
			sp.append("外键完整");
		}else if("2".equals(fkIntegrity)){
			sp.append("外键不完整");
		}else{
			sp.append("规则异常");
		}
		if(!TOOLS.StringIsEmpty(fkIntegrity)){
			if("0".equals(haveNull)){
				sp.append("");
			}else if("1".equals(haveNull)){
				sp.append(",无空值");
			}else if("2".equals(haveNull)){
				sp.append(",存在空值");
			}
		}
		return sp.toString();
	}

	/**
	 * 获取外键关系结果描述
	 * @param fkIntegrity 外键完整性
	 * @param haveNull    是否存在空值
	 * @return
	 */
	public static String getFkResultDescWithColor(String result,String fkIntegrity,String haveNull){
		StringBuilder sp = new StringBuilder();
		String color = null;
		if(Dbs_Reuslt_Type.Passed.toString().equals(result)){
			color = "blue";
		}else if(Dbs_Reuslt_Type.Failed.toString().equals(result)){
			color = "red";
		}
		if(color!=null){
			sp.append("<font color = '"+color+"'>");
		}
		if("0".equals(fkIntegrity)){
			sp.append("");
		}else if("1".equals(fkIntegrity)){
			sp.append("外键完整");
		}else if("2".equals(fkIntegrity)){
			sp.append("外键不完整");
		}
		if(!TOOLS.StringIsEmpty(fkIntegrity)){
			if("0".equals(haveNull)){
				sp.append("");
			}else if("1".equals(haveNull)){
				sp.append(",无空值");
			}else if("2".equals(haveNull)){
				sp.append(",存在空值");
			}
		}
		if(color!=null){
			sp.append("</font>");
		}
		return sp.toString();
	}

	/**
	 * 获取外键关系结果描述
	 * @param result      结果
	 * @param fkIntegrity 外键完整性
	 * @param haveNull    是否存在空值
	 * @param passColor   结果通过颜色
	 * @param failedColor 结果未通过颜色
	 * @return
	 */
	public static String getFkResultDescWithColor(String result,String fkIntegrity,String haveNull,
			String passColor,String failedColor){
		StringBuilder sp = new StringBuilder();
		String color = null;
		if(Dbs_Reuslt_Type.Passed.toString().equals(result)){
			color = passColor;
		}else if(Dbs_Reuslt_Type.Failed.toString().equals(result)){
			color = failedColor;
		}
		if(color!=null){
			sp.append(color);
		}
		if("0".equals(fkIntegrity)){
			sp.append("");
		}else if("1".equals(fkIntegrity)){
			sp.append("外键完整");
		}else if("2".equals(fkIntegrity)){
			sp.append("外键不完整");
		}
		if(!TOOLS.StringIsEmpty(fkIntegrity)){
			if("0".equals(haveNull)){
				sp.append("");
			}else if("1".equals(haveNull)){
				sp.append(",无空值");
			}else if("2".equals(haveNull)){
				sp.append(",存在空值");
			}
		}
		if(color!=null){
			sp.append(color);
		}
		return sp.toString();
	}

	/**
	 * 根据字段探查规则代码获取字段探查规则类型
	 * @param typeCode
	 * @return
	 */
	public static Field_Dbs_Rule_Type getFieldDbsRuleType(String typeCode){
		if(Field_Dbs_Rule_Type.Stand_Code.toString().equals(typeCode)){
			return Field_Dbs_Rule_Type.Stand_Code;
		}else if(Field_Dbs_Rule_Type.Symbol_Code.toString().equals(typeCode)){
			return Field_Dbs_Rule_Type.Symbol_Code;
		}else if(Field_Dbs_Rule_Type.Data_Range.toString().equals(typeCode)){
			return Field_Dbs_Rule_Type.Data_Range;
		}else if(Field_Dbs_Rule_Type.Null_Value.toString().equals(typeCode)){
			return Field_Dbs_Rule_Type.Null_Value;
		}else{
			return null;
		}
	}

	/**
	 * 获取字段探查规则类型描述
	 * @param typeCode 类型代码
	 * @return
	 */
	public static String getRuleTypeDesc(String typeCode){
		if(Field_Dbs_Rule_Type.Stand_Code.toString().equals(typeCode)){
			return "标准代码";
		}else if(Field_Dbs_Rule_Type.Symbol_Code.toString().equals(typeCode)){
			return "符号代码";
		}else if(Field_Dbs_Rule_Type.Data_Range.toString().equals(typeCode)){
			return "数据范围";
		}else if(Field_Dbs_Rule_Type.Null_Value.toString().equals(typeCode)){
			return "空值";
		}else{
			return null;
		}
	}
	
	/**
	 * 代码探查项匹配标志
	 */
	public enum Src_Code_Match_Flag{
		/** 匹配 */
		Match("1"),
		/** 未匹配 */
		No_Match("2");
		private String value;
		private Src_Code_Match_Flag(String value) {
			this.value = value;
		}
		public String toString() {
			return value;
		}
	}

	/**
	 * 探查规则树移动类型
	 */
	public enum Rule_Index_Move_Type{
		/** 前 */
		Before("0"),
		/** 后 */
		After("1"),
		/** 下级 */
		Child("2");
		private String value;
		private Rule_Index_Move_Type(String value) {
			this.value = value;
		}
		public String toString() {
			return value;
		}
	}

	/**
	 * 探查字段规则索引节点操作类型
	 */
	public enum Rule_Index_Operator_Type{
		/** 字段规则类型 */
		Rule_Type("1"),
		/** 字段规则主题 */
		Rule_Theme("2"),
		/** 字段规则 */
		Rule("3");
		private String value;
		private Rule_Index_Operator_Type(String value) {
			this.value = value;
		}
		public String toString() {
			return value;
		}
	}

	/**
	 * 探查字段规则索引类型
	 */
	public enum Rule_Index_Type{
		Stand_Code("1"),
		Symbol_Code("2"),
		Data_Range("3"),
		Empty_Value("4");
		private String value;
		private Rule_Index_Type(String value) {
			this.value = value;
		}
		public String toString() {
			return value;
		}
	}

	/**
	 * 存在空值
	 */
	public enum Have_Null_Value{
		/** 未知 */
		Unknow("0"),
		/** 无空值 */
		Not_Have_Null("1"),
		/** 有空值 */
		Have_Null("2");
		private String value;
		private Have_Null_Value(String value) {
			this.value = value;
		}
		public String toString() {
			return value;
		}
	}

	/**
	 * 外键完整
	 */
	public enum Fk_Integrity{
		/** 未知 */
		Unknow("0"),
		/** 完整 */
		Integrity("1"),
		/** 不完整 */
		Un_Integrity("2");
		private String value;
		private Fk_Integrity(String value) {
			this.value = value;
		}
		public String toString() {
			return value;
		}
	}

	/**
	 * 任务状态 
	 */
	public enum Status{
		/** 待启动 */
		NewTask("0"),
		/** 执行中 */
		Started("1"),
		/** 完成 */
		Finished("2"),
		/** 中止 */
		Terminate("3"),
		/** 异常结束*/
		Exception("4");
		private String value;
		private Status(String value){this.value=value;}
		public String toString() {return value;}
	}

	/**
	 * 探查标志
	 */
	public enum Flag_Code{
		/** 所有 */
		All("0"),
		/** 选择 */
		Only_Select("1");
		private String value;
		private Flag_Code(String value){this.value=value;}
		public String toString() {return value;}
	}

	/**
	 * 探查任务表状态
	 */
	public enum Dbs_Table_Status{
		/** 不探查 */
		Not_Search("0"),
		/** 待探查 */
		Will_Search("1"),
		/** 探查中 */
		Searching("2"),
		/** 结束 */
		Searched("3");
		private String value;
		private Dbs_Table_Status(String value){this.value=value;}
		public String toString() {return value;}
	}

	/**
	 * 获取规则类型
	 * @param indexType 规则类型
	 * @return
	 */
	public static Rule_Index_Type getRuleType(String indexType){
		if(Rule_Index_Type.Stand_Code.toString().equals(indexType)){
			return Rule_Index_Type.Stand_Code;
		}else if(Rule_Index_Type.Symbol_Code.toString().equals(indexType)){
			return Rule_Index_Type.Symbol_Code;
		}else if(Rule_Index_Type.Data_Range.toString().equals(indexType)){
			return Rule_Index_Type.Data_Range;
		}else if(Rule_Index_Type.Empty_Value.toString().equals(indexType)){
			return Rule_Index_Type.Empty_Value;
		}else{
			return null;
		}
	}

	/**
	 * 获取索引节点操作类型
	 * @param type
	 * @return
	 */
	public static String getIndexOperatorType(String type){
		if(Rule_Index_Operator_Type.Rule_Type.toString().equals(type)){
			return "规则类型";
		}else if(Rule_Index_Operator_Type.Rule_Theme.toString().equals(type)){
			return "规则主题";
		}else if(Rule_Index_Operator_Type.Rule.toString().equals(type)){
			return "规则";
		}else{
			return null;
		}
	}

	/**
	 * 获取空值描述
	 * @param haveNull
	 * @return
	 */
	public static String getHaveNull(String haveNull){
		if(Have_Null_Value.Unknow.toString().equals(haveNull)){
			return "未知";
		}else if(Have_Null_Value.Not_Have_Null.toString().equals(haveNull)){
			return "无空值";
		}else if(Have_Null_Value.Have_Null.toString().equals(haveNull)){
			return "有空值";
		}else{
			return null;
		}
	}

	/**
	 * 获取外键完整性描述
	 * @param fkIntegrity
	 * @return
	 */
	public static String getFkIntegrity(String fkIntegrity){
		if(Fk_Integrity.Unknow.toString().equals(fkIntegrity)){
			return "未知";
		}else if(Fk_Integrity.Integrity.toString().equals(fkIntegrity)){
			return "完整";
		}else if(Fk_Integrity.Un_Integrity.toString().equals(fkIntegrity)){
			return "不完整";
		}else{
			return null;
		}
	}

	/**
	 * 获取任务状态描述
	 * @param status 任务状态ID
	 * @return 任务状态描述
	 */
	public static String getStatusDesc(String status){
		if(Status.NewTask.toString().equals(status)){
			return "待启动";
		}else if(Status.Started.toString().equals(status)){
			return "执行中";
		}else if(Status.Finished.toString().equals(status)){
			return "完成";
		}else if(Status.Terminate.toString().equals(status)){
			return "中止";
		}else if(Status.Exception.toString().equals(status)){
			return "异常结束";
		}else{
			return null;
		}
	}
}

